home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / messact.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  27.1 KB  |  1,061 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 24
  2. /* Copyright (c) 1990-1992 by the University of Illinois Board of Trustees */
  3. #pragma load EUDORA_LOAD
  4. #pragma segment Message
  5.  
  6.     TEHandle MakeSubjectTXE(MessHandle messH);
  7.     void MessUpdate(MyWindowPtr win);
  8.     void MessSubjRect(MyWindowPtr win,Rect *r);
  9.     Boolean MessScroll(MyWindowPtr win,int h,int v);
  10.     void MessHelp(MyWindowPtr win,Point mouse);
  11.     short MyFSWrite(short refN,long *bytes,UPtr buffer);
  12.     void AddXlateTables(MyWindowPtr win,MenuHandle pmh);
  13.     void NewXlateTable(MyWindowPtr win,MenuHandle pmh,short item);
  14.     void MessZoomSize(MyWindowPtr win,Rect *zoom);
  15. #pragma segment Main
  16. /**********************************************************************
  17.  * MessClose - close a message window
  18.  **********************************************************************/
  19. Boolean MessClose(MyWindowPtr win)
  20. {
  21.     MessType **messH = (MessType **)((WindowPeek)win)->refCon;
  22.     TOCType **tocH = (*messH)->tocH;
  23.     int sumNum = (*messH)->sumNum;
  24.     
  25.     if (Win2Body(win) && WinTEH(win) && Win2Body(win)!=WinTEH(win)) MessSwapTXE(messH);
  26.     if ((*messH)->stes[0]) STEDispose((*messH)->stes[0]);
  27.     if ((*messH)->stes[1]) STEDispose((*messH)->stes[1]);
  28.     LL_Remove(MessList,messH,(MessType **));
  29.     DisposHandle(messH);
  30.     (*tocH)->sums[sumNum].messH = nil;
  31.     return(True);
  32. }
  33. #pragma segment Message
  34.  
  35. /**********************************************************************
  36.  * MessMenu - handle menu choices for a message window
  37.  **********************************************************************/
  38. Boolean MessMenu(MyWindowPtr win,int menu,int item,short modifiers)
  39. {
  40.     Str63 scratch, which;
  41.     MessType **messH = (MessType **)((WindowPeek)win)->refCon;
  42.     TOCType **tocH = (*messH)->tocH;
  43.     int sumNum = (*messH)->sumNum;
  44.     Boolean result = False;
  45.     long dirId;
  46.     short function;
  47.     
  48.     switch (menu)
  49.     {
  50.         case FILE_MENU:
  51.             switch(item)
  52.             {
  53.                 case FILE_PRINT_ITEM:
  54.                 case FILE_PRINT_SELECT_ITEM:
  55.                     PrintOneMessage((*messH)->win,item==FILE_PRINT_SELECT_ITEM);
  56.                     result = True;
  57.                     break;
  58.                 case FILE_SAVE_AS_ITEM:
  59.                     SaveMessageAs(messH);
  60.                     result = True;
  61.                     break;
  62.             }
  63.             break;
  64.         case EDIT_MENU:
  65.             if (win->ro)
  66.                 switch (item)
  67.                 {
  68.                     case EDIT_COPY_ITEM:
  69.                         result = TESomething(win,item,0,modifiers);
  70.                         break;
  71.                 }
  72.             else
  73.             {
  74.                 result = TESomething(win,item,0,modifiers);
  75.                 if (item==EDIT_PASTE_ITEM || item==EDIT_QUOTE_ITEM)
  76.                 {
  77.                     Boolean foundOne=False;
  78.                     TEHandle teh = (*Win2MessH(win))->txes[SUBJ_HEAD-1];
  79.                     char *spot = *(*teh)->hText;
  80.                     char *end = spot + (*teh)->teLength;
  81.                     for (;spot<end;spot++)
  82.                         if (*spot=='\n') {*spot=' '; foundOne=True;}
  83.                     if (foundOne) {ResizeSTE(win->ste,nil);}
  84.                 }
  85.             }
  86.             break;
  87.         case MESSAGE_MENU:
  88.             switch (item)
  89.             {
  90.                 case MESSAGE_REPLY_ITEM:
  91.                     DoReplyMessage(win,modifiers,0,True);
  92.                     result = True;
  93.                     break;
  94.                 case MESSAGE_REDISTRIBUTE_ITEM:
  95.                     DoRedistributeMessage(win,0);
  96.                     result = True;
  97.                     break;
  98.                 case MESSAGE_FORWARD_ITEM:
  99.                     DoForwardMessage(win,0);
  100.                     result = True;
  101.                     break;
  102.                 case MESSAGE_SALVAGE_ITEM:
  103.                     DoSalvageMessage(win);
  104.                     result = True;
  105.                     break;
  106.                 case MESSAGE_DELETE_ITEM:
  107.                     if (CloseMyWindow(win))
  108.                     {
  109.                         DeleteMessage(tocH,sumNum);
  110.                         if ((*tocH)->win)
  111.                         {
  112.                             if (!PrefIsSet(PREF_NO_AUTO_OPEN) && sumNum<(*tocH)->count &&
  113.                                     (*tocH)->sums[sumNum].state==UNREAD)
  114.                             {
  115.                                 SelectBoxRange(tocH,sumNum,sumNum,False,-1,-1);
  116.                                 BoxOpen((*tocH)->win);
  117.                             }
  118.                             else
  119.                                 BoxSelectAfter((*tocH)->win,sumNum);
  120.                         }
  121.                     }
  122.                     result = True;
  123.                     break;
  124.             }
  125.             break;
  126.         case REPLY_TO_HIER_MENU:
  127.             DoReplyMessage(win,modifiers,item,True);
  128.             result = True;
  129.             break;
  130.         case FORWARD_TO_HIER_MENU:
  131.             DoForwardMessage(win,item);
  132.             result = True;
  133.             break;
  134.         case REDIST_TO_HIER_MENU:
  135.             DoRedistributeMessage(win,item);
  136.             result = True;
  137.             break;
  138.         case SPECIAL_MENU:
  139.             switch(item)
  140.             {
  141.                 case SPECIAL_MAKE_NICK_ITEM:
  142.                     MakeMessNick(win,modifiers);
  143.                     result = True;
  144.                     break;
  145.             }
  146.             break;
  147.         case PRIOR_MENU:
  148.             SetPriority(tocH,(*messH)->sumNum,Display2Prior(item));
  149.             result = True;
  150.             break;
  151.         default:
  152.             if (menu==TRANSFER_MENU)
  153.             {
  154.                 dirId = MyDirId;
  155.                 function = TRANSFER;
  156.             }
  157.             else if (menu<1||menu>=FIND_HIER_MENU) break;
  158.             else
  159.             {
  160.                 dirId = (*BoxMap)[menu % MAX_BOX_LEVELS];
  161.                 function = (menu-1)/MAX_BOX_LEVELS;
  162.             }
  163.             switch (function)
  164.             {
  165.                 case TRANSFER:
  166.                     PCopy(scratch,(*tocH)->name);
  167.                     if (GetTransferParams(menu,item,&dirId,which) &&
  168.                             (dirId!=(*tocH)->dirId || !EqualString(which,scratch,False,True)))
  169.                     {
  170.                         MoveMessage(tocH,sumNum,dirId,which,(modifiers&optionKey)!=0);
  171.                         if ((*tocH)->win && !(modifiers&optionKey))
  172.                         {
  173.                             BoxSelectAfter((*tocH)->win,sumNum);
  174.                             if (!PrefIsSet(PREF_NO_AUTO_OPEN) && (sumNum=BoxNextSelected(tocH,-1))>=0 && (*tocH)->sums[sumNum].state==UNREAD)
  175.                                 BoxOpen((*tocH)->win);
  176.                         }
  177.                     }
  178.                     result=True;
  179.                     break;
  180.                 default:
  181.                     break;
  182.             }
  183.     }
  184.     return(result);
  185. } 
  186.  
  187. /************************************************************************
  188.  * SaveMessageAs - save a message in text only form
  189.  ************************************************************************/
  190. void SaveMessageAs(MessHandle messH)
  191. {
  192.     long creator;
  193.     short vRefN, refN;
  194.     short err;
  195.     Str31 scratch,name;
  196.     
  197.     /*
  198.      * tickle stdfile
  199.      */
  200.     GetPref(scratch,PREF_CREATOR);
  201.     if (*scratch!=4) GetRString(scratch,TEXT_CREATOR);
  202.     BlockMove(scratch+1,&creator,4);
  203.     MakeMessFileName((*messH)->tocH,(*messH)->sumNum,name);
  204.     ExcludeHeaders = PrefIsSet(PREF_EXCLUDE_HEADERS);
  205.     Paragraphs = PrefIsSet(PREF_PARAGRAPHS);
  206.     if (err=SFPutOpen(name,&vRefN,creator,'TEXT',&refN,SaveAsFilter,SAVEAS_DLOG))
  207.         return;
  208.     
  209.     /*
  210.      * do it
  211.      */
  212.     err = SaveAsToOpenFile(refN,messH);
  213.     
  214.     /*
  215.      * close
  216.      */
  217.     (void) FSClose(refN);
  218.     
  219.     /*
  220.      * report error
  221.      */
  222.     if (err)
  223.     {
  224.         FileSystemError(COULDNT_SAVEAS,name,err);
  225.         FSDelete(name,vRefN);
  226.     }
  227. }
  228.  
  229. /************************************************************************
  230.  * SaveAsToOpenFile - continue the message saving process
  231.  ************************************************************************/
  232. short SaveAsToOpenFile(short refN,MessHandle messH)
  233. {
  234.     long bytes;
  235.     short err=0, itx;
  236.     UPtr where;
  237.     TEHandle teh=BodyOf(messH);
  238.     Str63 scratch;
  239.     
  240.     if (!Paragraphs)
  241.     {
  242.         if ((*messH)->txes[0])
  243.         {
  244.             for (itx=ExcludeHeaders?HEAD_LIMIT-1:0;!err && itx<HEAD_LIMIT;itx++)
  245.             {
  246.                 if (itx<HEAD_LIMIT-1)
  247.                 {
  248.                     GetRString(scratch,HEADER_STRN+itx+1);
  249.                     PCatC(scratch,' ');
  250.                     bytes = *scratch;
  251.                     (void) FSWrite(refN,&bytes,scratch+1);
  252.                 }
  253.                 bytes = (*(*messH)->txes[itx])->teLength;
  254.                 err = FSWrite(refN,&bytes,LDRef((*(*messH)->txes[itx])->hText));
  255.                 UL((*(*messH)->txes[itx])->hText);
  256.                 bytes = 1;
  257.                 if (!err) err = FSWrite(refN,&bytes,"\n");
  258.             }
  259.         }
  260.         else
  261.         {
  262.             where = LDRef((*teh)->hText);
  263.             bytes = (*teh)->teLength;
  264.             if (ExcludeHeaders)
  265.             {
  266.                 where += SumOf(messH)->bodyOffset - (*messH)->weeded;
  267.                 bytes -= SumOf(messH)->bodyOffset - (*messH)->weeded;
  268.                 while (bytes > 1 && *where == '\n') {where++;bytes--;}
  269.                 while (bytes>1&&where[bytes-1]==where[bytes-2]&&where[bytes-1]=='\n')
  270.                     bytes--;
  271.             }
  272.             err = FSWrite(refN,&bytes,where);
  273.             UL((*teh)->hText);
  274.         }
  275.     }
  276.     else
  277.     {
  278.         if ((*messH)->txes[0])
  279.         {
  280.             for (itx=ExcludeHeaders?HEAD_LIMIT-1:0;!err && itx<HEAD_LIMIT;itx++)
  281.             {
  282.                 if (itx<HEAD_LIMIT-1)
  283.                 {
  284.                     GetRString(scratch,HEADER_STRN+itx+1);
  285.                     PCatC(scratch,' ');
  286.                     bytes = *scratch;
  287.                     (void) FSWrite(refN,&bytes,scratch+1);
  288.                 }
  289.                 err = UnwrapSave(LDRef((*(*messH)->txes[itx])->hText),
  290.                                                  (*(*messH)->txes[itx])->teLength,0,refN);
  291.                 UL((*(*messH)->txes[itx])->hText);
  292.                 if (itx<HEAD_LIMIT-1 && !err)
  293.                 {
  294.                     bytes = 1;
  295.                     err = FSWrite(refN,&bytes,"\n");
  296.                 }
  297.             }
  298.         }
  299.         else
  300.         {
  301.             where = LDRef((*teh)->hText);
  302.             bytes = (*teh)->teLength;
  303.             if (ExcludeHeaders)
  304.             {
  305.                 where += SumOf(messH)->bodyOffset - (*messH)->weeded;
  306.                 bytes -= SumOf(messH)->bodyOffset - (*messH)->weeded;
  307.                 while (bytes > 1 && *where == '\n') {where++;bytes--;}
  308.                 while (bytes>1&&where[bytes-1]==where[bytes-2]&&where[bytes-1]=='\n')
  309.                     bytes--;
  310.             }
  311.             err = UnwrapSave(where,bytes,0,refN);
  312.             UL((*teh)->hText);
  313.         }
  314.     }
  315.     return(err);
  316. }
  317.  
  318. /************************************************************************
  319.  * UnwrapSave - save and unwrap a message
  320.  ************************************************************************/
  321. #define flushBChars() do {                                                                            \
  322.     if (bytes=bSpot-buffer)                                                                             \
  323.     {                                                                                                                         \
  324.          err = refN ? FSWrite(refN,&bytes,buffer) :                                 \
  325.          (WrapHandle ? PtrAndHand(buffer,WrapHandle,bytes) : noErr);\
  326.          if (err) goto done;                                                                                \
  327.          bSpot = buffer;                                                                                        \
  328.     }                                                                                                                         \
  329. } while (0)
  330. #define putBChar(theC) do {                                                                         \
  331.     *bSpot++ = theC;                                                                                            \
  332.     if (bSpot==bEnd) flushBChars();                                                             \
  333. } while (0)
  334. int UnwrapSave(UPtr text, short length, short offset, short refN)
  335. {
  336.     struct LineInfo
  337.     {
  338.             int length;
  339.             int indent;
  340.             int quote;
  341.             int needReturn;
  342.     };
  343.     struct LineInfo lines[2];
  344.     struct LineInfo *this, *last;
  345.     int flip;
  346.     int c;
  347.     UPtr tSpot;
  348.     int begin;
  349.     int spaces;
  350.     UPtr buffer = NuPtr(BUFFER_SIZE);
  351.     UPtr bSpot, bEnd;
  352.     int err=0;
  353.     long bytes;
  354.     Str31 s;
  355.     Byte quote=GetRString(s,QUOTE_PREFIX)[1];
  356.     short i;
  357.     
  358.     
  359.     if (!buffer) return(MemError());
  360.     bEnd = buffer+BUFFER_SIZE;
  361.     bSpot = buffer;
  362.  
  363.     WriteZero(lines,sizeof(lines));
  364.     this = lines;
  365.     last = lines+1;
  366.     flip=this->length=this->indent=this->needReturn=last->length=last->indent=0;
  367.     last->needReturn=begin=1;
  368.  
  369.     for (tSpot=text+offset;tSpot<text+length;tSpot++)
  370.     {
  371.         c = *tSpot;
  372.         if (c=='\n')
  373.         {
  374.             this->needReturn =    this->needReturn ||
  375.                                 this->indent>20 || this->length<40;
  376.             if (this->needReturn)
  377.             {
  378.                 if (this->length==0 && !last->needReturn)
  379.                 {
  380.                     putBChar('\n');
  381.                 }
  382.                 putBChar('\n');
  383.             }
  384.             else
  385.                 putBChar(' ');
  386.             last = this;
  387.             flip = 1-flip;
  388.             this = lines + flip;
  389.             this->length = this->quote = this->indent = this->needReturn = 0;
  390.             begin = 1;
  391.             spaces = 0;
  392.         }
  393.         else if (c==' ')
  394.         {
  395.             if (begin) this->indent++;
  396.             else spaces++;
  397.         }
  398.         else if (begin && c==quote)
  399.         {
  400.             this->quote++;
  401.         }
  402.         else
  403.         {
  404.             if (!begin)
  405.             {
  406.                 if (spaces>4 && SendWDS!=WrapSendWDS)
  407.                 {
  408.                     putBChar('\t');
  409.                     this->needReturn = 1;
  410.                 }
  411.                 else if (spaces)
  412.                 {
  413.                     putBChar(' ');
  414.                     this->length++;
  415.                 }
  416.             }
  417.             else if ((this->indent>last->indent || this->quote!=last->quote) &&
  418.                              !last->needReturn)
  419.             {
  420.                 putBChar('\n');
  421.                 for (i=0;i<this->quote;i++) putBChar(c);
  422.                 this->length += this->quote;
  423.             }
  424.             else if (this->quote && last->needReturn)
  425.             {
  426.                 for (i=0;i<this->quote;i++) putBChar(quote);
  427.                 this->length += this->quote;
  428.             }
  429.             begin = 0;
  430.             spaces = 0;
  431.             putBChar(c);
  432.             this->length++;
  433.         }
  434.     }
  435.     flushBChars();
  436. done:
  437.     DisposPtr(buffer);
  438.     return(err);
  439. }
  440.  
  441. /************************************************************************
  442.  * MessKey - handle a keydown in a message window
  443.  ************************************************************************/
  444. void MessKey(MyWindowPtr win, EventRecord *event)
  445. {
  446.     MessHandle messH = (MessHandle)win->qWindow.refCon;
  447.     TOCHandle tocH = (*messH)->tocH;
  448.     long uLetter = UnadornMessage(event)&charCodeMask;
  449.     
  450.     if (leftArrowChar<=uLetter && uLetter<=downArrowChar &&
  451.             ((event->modifiers&cmdKey)!=0 ?
  452.                 !PrefIsSet(PREF_NO_CMD_ARROW):PrefIsSet(PREF_PLAIN_ARROW)))
  453.     {
  454.         NextMess(tocH,messH,uLetter,event->modifiers);
  455.         return;
  456.     }
  457.     else if ((*messH)->txes[SUBJ_HEAD-1] &&
  458.                      (uLetter==tabChar || uLetter==enterChar))
  459.     {
  460.         MessSwapTXE(messH);
  461.         if (WinTEH(win) != BodyOf(messH)) TESetSelect(0,INFINITY,WinTEH(win));
  462.     }
  463.     else if (event->modifiers&cmdKey)
  464.     {
  465.         if ('1'<=uLetter && uLetter<='5')
  466.             SetPriority(tocH,(*messH)->sumNum,Display2Prior(uLetter-'0'));
  467.         else
  468.             SysBeep(20L);
  469.         return;
  470.     }
  471.     else if (win->ro && DirtyKey(event->message))
  472.         AlertStr(READ_ONLY_ALRT, Stop, nil);
  473.     else if (!win->ro && (uLetter==upArrowChar || uLetter==downArrowChar
  474.                      || uLetter==returnChar))
  475.         SysBeep(20L);
  476.     else
  477.     {
  478.         TEActivate((*(STEHandle)win->ste)->te);
  479.         TESomething(win,TEKEY,(short)(event->message & 0xff),event->modifiers);
  480.     }
  481. }
  482.  
  483. /************************************************************************
  484.  * NextMess - skip to the next message
  485.  ************************************************************************/
  486. void NextMess(TOCHandle tocH,MessHandle messH,short whichWay,long modifiers)
  487. {
  488.     MyWindowPtr win;
  489.     short next;
  490.     
  491.     switch (whichWay)
  492.     {
  493.         case upArrowChar:
  494.         case leftArrowChar:
  495.             next = (*messH)->sumNum-1;
  496.             break;
  497.         case downArrowChar:
  498.         case rightArrowChar:
  499.             next = (*messH)->sumNum+1;
  500.             break;
  501.         default:
  502.             return;
  503.     }
  504.     if (next!=(*messH)->sumNum)
  505.     {
  506.         if (!(modifiers & optionKey)) CloseMyWindow((*messH)->win);
  507.         if (next<0 || next>=(*tocH)->count) return;
  508.         if ((*tocH)->sums[next].messH)
  509.         {
  510.             win=(*(MessHandle)(*tocH)->sums[next].messH)->win;
  511.             ShowMyWindow(win);
  512.             SelectWindow(win);
  513.         }
  514.         else
  515.             (void) GetAMessage(tocH,next,nil,True);
  516.         SelectBoxRange(tocH,next,next,False,-1,-1);
  517.         BoxCenterSelection((*tocH)->win);
  518.     }
  519. }
  520.  
  521. /************************************************************************
  522.  * SaveAsFilter - look for hits on our two special items
  523.  ************************************************************************/
  524. pascal Boolean SaveAsFilter(DialogPtr dgPtr,EventRecord *event,short *item)
  525. {
  526.     Rect r;
  527.     short type;
  528.     Handle itemH;
  529.     Point mouse;
  530.     GrafPtr oldPort;
  531.     
  532.     GetPort(&oldPort);
  533.     SetPort(dgPtr);
  534.     if (event->what==nullEvent || event->what==updateEvt)
  535.     {
  536.         if (GetDItemState(dgPtr,SADL_PARAGRAPHS)!=Paragraphs)
  537.             SetDItemState(dgPtr,SADL_PARAGRAPHS,Paragraphs);
  538.         if (GetDItemState(dgPtr,SADL_EXCLUDE_HEADERS)==ExcludeHeaders)
  539.             SetDItemState(dgPtr,SADL_EXCLUDE_HEADERS,!ExcludeHeaders);
  540.     }
  541.     else if (event->what==mouseDown)
  542.     {
  543.         mouse = event->where;
  544.         GlobalToLocal(&mouse);
  545.         itemH = nil;
  546.         GetDItem(dgPtr,SADL_PARAGRAPHS,&type,&itemH,&r);
  547.         if (!itemH) goto done;
  548.         if (PtInRect(mouse,&r))
  549.         {
  550.             if (TrackControl(itemH,mouse,nil))
  551.             {
  552.                 Paragraphs = !GetDItemState(dgPtr,SADL_PARAGRAPHS);
  553.                 SetDItemState(dgPtr,SADL_PARAGRAPHS,Paragraphs);
  554.             }
  555.             goto done;
  556.         }
  557.         else
  558.         {
  559.             GetDItem(dgPtr,SADL_EXCLUDE_HEADERS,&type,&itemH,&r);
  560.             if (!itemH) goto done;
  561.             if (PtInRect(mouse,&r))
  562.             {
  563.                 if (TrackControl(itemH,mouse,nil))
  564.                 {
  565.                     ExcludeHeaders = GetDItemState(dgPtr,SADL_EXCLUDE_HEADERS);
  566.                     SetDItemState(dgPtr,SADL_EXCLUDE_HEADERS,!ExcludeHeaders);
  567.                 }
  568.                 goto done;
  569.             }
  570.         }
  571.     }
  572.     SetPort(oldPort);
  573.     return(DlgFilter(dgPtr,event,item));
  574.     
  575.     done:
  576.         SetPort(oldPort);
  577.         return(False);
  578. }
  579.  
  580. /************************************************************************
  581.  * MessClick - handle a click in the message window
  582.  ************************************************************************/
  583. void MessClick(MyWindowPtr win,EventRecord *event)
  584. {
  585.     Point pt = event->where;
  586.     Rect r,pr;
  587.     STEHandle ste=nil;
  588.     MessHandle messH = Win2MessH(win);
  589.     
  590.     GlobalToLocal(&pt);
  591.     r = (*(*messH)->stes[0])->encloseR;
  592.     if (GetPriorityRect(win,&pr) && PtInRect(pt,&pr))
  593.         PriorityMenu(win);
  594.     else if (PtInRect(pt,&r)) ste = (*messH)->stes[0];
  595.     else if ((*messH)->stes[1])
  596.     {
  597.         r = (*(*messH)->stes[1])->encloseR;
  598.         if (PtInRect(pt,&r)) ste = (*messH)->stes[1];
  599.     }
  600.     
  601.     if (ste)
  602.     {
  603.       if (win->ste != ste) MessSwapTXE(messH);
  604.         STEClick(win->ste,event);
  605.     }
  606.     else HandleControl(pt,win);
  607. }
  608.  
  609. /************************************************************************
  610.  * MessGonnaShow - get ready to show a message window
  611.  ************************************************************************/
  612. void MessGonnaShow(MyWindowPtr win)
  613. {
  614.     MessHandle messH = (MessHandle)win->qWindow.refCon;
  615.     short margin;
  616.     
  617.     win->didResize = MessDidResize;
  618.     win->key = MessKey;
  619.     win->update = MessUpdate;
  620.     win->help = MessHelp;
  621.     win->dontControl = True;
  622.     win->zoomSize = MessZoomSize;
  623.     if (PrefIsSet(PREF_ICON_BAR))
  624.     {
  625.         margin = 2*FontLead+FontDescent+2;
  626.         win->topMargin = win->contR.top = margin;
  627.         if (MakeSubjectTXE(messH))
  628.             win->click = MessClick;
  629.         else
  630.             win->topMargin = win->contR.top = 0;
  631.         ResizeSTE((*messH)->stes[0],&win->contR);
  632.     }
  633.     MyWindowDidResize(win,nil);
  634.     TEActivate(WinTEH(win));
  635. }
  636.  
  637. /************************************************************************
  638.  * MakeSubjectTXE - make a TERec for the subject
  639.  ************************************************************************/
  640. TEHandle MakeSubjectTXE(MessHandle messH)
  641. {
  642.     Str63 subject;
  643.     Rect view;
  644.     MyWindowPtr win=(*messH)->win;
  645.     STEHandle ste;
  646.     GrafPtr oldPort;
  647.     
  648.     GetPort(&oldPort);
  649.     SetPort(win);
  650.     
  651.     PCopy(subject,SumOf(messH)->subj);
  652.     
  653.     MessSubjRect(win,&view);
  654.  
  655.     if (ste=NewSTE(win,&view,False,False,True))
  656.     {
  657.         (*(*ste)->te)->crOnly = -1;
  658.         (*ste)->dontFrame = True;
  659.         STESetText(subject+1,*subject,ste);
  660.         (*messH)->txes[SUBJ_HEAD-1] = (*ste)->te;
  661.         (*messH)->stes[1] = ste;
  662.     }
  663.     
  664.     SetPort(oldPort);
  665.     return(ste ? (*ste)->te : nil);
  666. }
  667.  
  668. /************************************************************************
  669.  * MessUpdate - update a message window
  670.  ************************************************************************/
  671. void MessUpdate(MyWindowPtr win)
  672. {
  673.     Rect pr;
  674.     
  675.     if (win->qWindow.visible)
  676.     {
  677.         MessHandle messH = (MessHandle)win->qWindow.refCon;
  678.         TOCHandle tocH = (*messH)->tocH;
  679.         if (SumOf(messH)->state==UNREAD)
  680.             SetState(tocH,(*messH)->sumNum,READ);
  681.         if ((*messH)->txes[BODY])
  682.             STEUpdate((*messH)->stes[0]);
  683.         if ((*messH)->txes[SUBJ_HEAD-1])
  684.         {
  685.             Str31 label;
  686.             TEHandle teh = (*messH)->txes[SUBJ_HEAD-1];
  687.  
  688.             /*
  689.              * draw separators
  690.              */
  691.             MoveTo(0,win->topMargin); Line(INFINITY,0);
  692.             Move(0,-2); Line(-INFINITY,0);
  693.                         
  694.             /*
  695.              * draw priority
  696.              */
  697.             if (GetPriorityRect(win,&pr)) DrawPriority(&pr,SumOf(messH)->priority);
  698.                 
  699.             /*
  700.              * draw label
  701.              */
  702.             MoveTo(pr.right+FontWidth,(3*FontLead)/2);
  703.             GetRString(label,HEADER_STRN+SUBJ_HEAD);
  704.             DrawString(label);
  705.                         
  706.             /*
  707.              * and the text
  708.              */
  709.             STEUpdate((*messH)->stes[1]);
  710.         }
  711.     }
  712. }
  713.  
  714. /************************************************************************
  715.  * MessSwapTXE - switch txe's in a message window
  716.  ************************************************************************/
  717. void MessSwapTXE(MessHandle messH)
  718. {
  719.     MyWindowPtr win = (*messH)->win;
  720.     TEHandle subTeh = (*messH)->txes[SUBJ_HEAD-1];
  721.     TEHandle bodTeh = (*messH)->txes[BODY];
  722.     TEHandle newTeh = (WinTEH(win)==bodTeh) ? subTeh : bodTeh;
  723.  
  724.     TEDeactivate(WinTEH(win));
  725.     TEActivate(newTeh);
  726.     if (newTeh==bodTeh)
  727.   {
  728.         win->ste = (*messH)->stes[0];
  729.         win->ro = True;
  730.     }
  731.     else
  732.     {
  733.         win->ste = (*messH)->stes[1];
  734.         win->ro = False;
  735.     }
  736.     if (win->ro)
  737.     {
  738.         Str63 newSubj;
  739.         Str63 oldSubj;
  740.         Str255 title;
  741.         
  742.         win->showInsert = nil;
  743.         *newSubj = MIN(63,(*subTeh)->teLength);
  744.         BlockMove(*(*subTeh)->hText,newSubj+1,*newSubj);
  745.         PCopy(oldSubj,SumOf(messH)->subj);
  746.         if (!EqualString(oldSubj,newSubj,True,True))
  747.         {
  748.             PCopy(SumOf(messH)->subj,newSubj);
  749.             InvalSum((*messH)->tocH,(*messH)->sumNum);
  750.             CalcSumLengths((*messH)->tocH,(*messH)->sumNum);
  751.             (*(*messH)->tocH)->dirty = True;
  752.             MakeMessTitle(title,(*messH)->tocH,(*messH)->sumNum);
  753.             SetWTitle(win,title);
  754.         }
  755.     }
  756.     else win->showInsert = NOOP;
  757. }
  758.  
  759. /************************************************************************
  760.  * MessDidResize - resize a message window
  761.  ************************************************************************/
  762. void MessDidResize(MyWindowPtr win, Rect *oldContR)
  763. {
  764.     MessHandle messH = (MessHandle)win->qWindow.refCon;
  765.     Rect view;
  766.     TEHandle bodTeh = (*messH)->txes[BODY];
  767.     TEHandle subTeh = (*messH)->txes[SUBJ_HEAD-1];
  768.     
  769.     win->contR = ((GrafPtr)win)->portRect;
  770.     if (!subTeh)
  771.         TextDidResize(win,oldContR);
  772.     else
  773.     {
  774.         MessSubjRect(win,&view); 
  775.         ResizeSTE((*messH)->stes[1],&view);
  776.         win->contR.top = win->topMargin;
  777.         view = win->contR;
  778.         view.right+=1;
  779.         ResizeSTE((*messH)->stes[0],&view);
  780.     }
  781. }
  782.  
  783. /************************************************************************
  784.  * MessSubjRect - find the rect for the subject teh
  785.  ************************************************************************/
  786. void MessSubjRect(MyWindowPtr win,Rect *r)
  787. {
  788.     Str31 label;
  789.     MessHandle messH = Win2MessH(win);
  790.     short hi = win->vPitch+2*TE_VMARGIN+FontDescent;
  791.     Rect pr;
  792.     
  793.     GetPriorityRect(win,&pr);
  794.  
  795.     *r = win->contR;
  796.     r->left += pr.right + 
  797.         StringWidth(GetRString(label,HEADER_STRN+SUBJ_HEAD))+2*win->hPitch;
  798.     r->top = (3*win->vPitch)/2-FontAscent-TE_VMARGIN-1;
  799.     r->bottom = r->top+hi;
  800.     r->right -= GROW_SIZE;
  801. }
  802.  
  803. /************************************************************************
  804.  * MessCursor - set the cursor properly
  805.  ************************************************************************/
  806. void MessCursor(Point mouse)
  807. {
  808.     MyWindowPtr win=FrontWindow();
  809.     MessHandle messH = Win2MessH(win);
  810.     
  811.     if (CursorInRect(mouse,(*(*(*messH)->stes[0])->te)->viewRect,MouseRgn) ||
  812.             win->topMargin && CursorInRect(mouse,(*(*(*messH)->stes[1])->te)->viewRect,MouseRgn))
  813.         SetMyCursor(iBeamCursor);
  814.     else
  815.         SetMyCursor(arrowCursor);
  816. }
  817.  
  818.  
  819. /************************************************************************
  820.  * GetPriorityRect - where does the priority thing belong?
  821.  ************************************************************************/
  822. Boolean GetPriorityRect(MyWindowPtr win,Rect *pr)
  823. {
  824.     short v;
  825.     if (!win->topMargin)
  826.     {
  827.         SetRect(pr,0,0,0,0);
  828.         return(False);
  829.     }
  830.     else
  831.     {
  832.         v = (win->topMargin-16)/2;
  833.         SetRect(pr,v,v,v+16,v+16);
  834. #ifdef NEVER
  835.         pr->right += FontWidth*10;
  836. #endif
  837.         return(True);
  838.     }
  839. }
  840.  
  841. /************************************************************************
  842.  * DrawPriority - draw the message priority
  843.  ************************************************************************/
  844. void DrawPriority(Rect *pr,short p)
  845. {
  846.     SICNHand theSICN;
  847.     Rect ir = *pr;
  848.     ir.right = ir.left+16;
  849.     
  850.     p = Prior2Display(p);
  851.     if (theSICN = GetResource('SICN',PRIOR_SICN_BASE+p-1))
  852.         PlotSICN(&ir,theSICN,0);
  853.     if (((WindowPeek)qd.thePort)->windowKind!=CBOX_WIN &&((WindowPeek)qd.thePort)->windowKind!=MBOX_WIN)
  854.     {
  855. #ifdef NEVER
  856.         Str31 string;
  857.         MoveTo(ir.right+FontWidth/2,(3*FontLead)/2);
  858.         GetRString(string,PRIOR_STRN+p);
  859.         TextFont(FontID);
  860.         TextSize(FontSize);
  861.         DrawString(string);
  862. #endif
  863.         ir = *pr;
  864.         if (FontLead+FontDescent > 16) InsetRect(&ir,0,(16-FontDescent-FontLead)/2);
  865.         FrameRect(&ir);
  866.         MoveTo(ir.left+1,ir.bottom);
  867.         Line(ir.right-ir.left-1,0);
  868.         Line(0,ir.top-ir.bottom+1);
  869.     }
  870. }
  871.  
  872. /************************************************************************
  873.  * PriorityMenu - put up the priority menu, and set the priority
  874.  ************************************************************************/
  875. short PriorityMenu(MyWindowPtr win)
  876. {
  877.     MenuHandle pmh = GetMenu(PRIOR_MENU);
  878.     Rect pr;
  879.     MessHandle messH = Win2MessH(win);
  880.     short p = SumOf(messH)->priority;
  881.     long res;
  882.     short item;
  883.     
  884.     if (pmh)
  885.     {
  886.         AddXlateTables(win,pmh);
  887.         GetPriorityRect(win,&pr);
  888.         BitClr((Ptr)HiliteMode, pHiliteBit);
  889.         p = Prior2Display(p);
  890.         LocalToGlobal((Point *)&pr);
  891.         
  892.         InsertMenu(pmh,-1);
  893.         res = PopUpMenuSelect(pmh,pr.top,pr.left,p);
  894.         item = res&0xffff0000 ? res&0xff : 0;
  895.         if (item && item > XLATE_BAR_ITEM) NewXlateTable(win,pmh,item);
  896.         DeleteMenu(PRIOR_MENU);
  897.         
  898.         if (item && item<=5)
  899.         {
  900.             p = Display2Prior(item);
  901.             SetPriority((*messH)->tocH,(*messH)->sumNum,p);
  902.         }
  903.         else res = 0;
  904.         
  905.         DisposeMenu(pmh);
  906.     }
  907.     return(p);
  908. }
  909.  
  910.  
  911. /************************************************************************
  912.  * AddXlateTables - add named translate tables to the current menu
  913.  ************************************************************************/
  914. void AddXlateTables(MyWindowPtr win,MenuHandle pmh)
  915. {
  916.     Boolean added=False;
  917.     short i,n;
  918.     Handle h;
  919.     Str31 name;
  920.     long type;
  921.     short id;
  922.     short nowId = SumOf(Win2MessH(win))->tableId;
  923.     Boolean isOut = (*(*Win2MessH(win))->tocH)->which == OUT;
  924.     short defltId = GetRLong(PREF_STRN+(isOut ? PREF_OUT_XLATE : PREF_IN_XLATE));
  925.     
  926.     n = CountResources('taBL');
  927.     SetResLoad(False);
  928.     for (i=1;i<=n;i++)
  929.         if (h=GetIndResource('taBL',i))
  930.         {
  931.             GetResInfo(h,&id,&type,name);
  932.             ReleaseResource(h);
  933.             if (!ResError() && *name && ((id%2)==0)==isOut)
  934.             {
  935.                 if (!added)
  936.                 {
  937.                     added = True;
  938.                     AppendMenu(pmh,"\p-");
  939.                 }
  940.                 MyAppendMenu(pmh,name);
  941.                 if (id==defltId) SetItemStyle(pmh,CountMItems(pmh),outline);
  942.                 if (id==nowId || (id==defltId && nowId==DEFAULT_TABLE))
  943.                     SetItemMark(pmh,CountMItems(pmh),checkMark);
  944.             }
  945.         }
  946.     SetResLoad(True);
  947. }
  948.  
  949. /************************************************************************
  950.  * NewXlateTable - change the translate table for a window
  951.  ************************************************************************/
  952. void NewXlateTable(MyWindowPtr win,MenuHandle pmh,short item)
  953. {
  954.     Boolean makeDefault = (CurrentModifiers()&shiftKey)!=0;
  955.     short newId,mark=False;
  956.     long type;
  957.     Str31 name;
  958.     Handle h;
  959.     Boolean isOut = (*(*Win2MessH(win))->tocH)->which == OUT;
  960.     short id = SumOf(Win2MessH(win))->tableId;
  961.  
  962.     if (makeDefault) GetItemStyle(pmh,item,&mark);
  963.     else GetItemMark(pmh,item,&mark);
  964.     if (mark)
  965.         newId = NO_TABLE;
  966.     else
  967.     {
  968.         MyGetItem(pmh,item,name);
  969.         SetResLoad(False);
  970.         if (h=GetNamedResource('taBL',name))
  971.         {
  972.             GetResInfo(h,&newId,&type,name);
  973.             if (ResError()) newId = id;    /* do nothing */
  974.             ReleaseResource(h);
  975.         }
  976.         SetResLoad(True);
  977.     }
  978.     if (makeDefault)
  979.     {
  980.         NumToString(newId,name);
  981.         ChangeStrn(PREF_STRN,(isOut?PREF_OUT_XLATE:PREF_IN_XLATE),name);
  982.     }
  983.     else if (id!=newId)
  984.     {
  985.         SumOf(Win2MessH(win))->tableId = newId;
  986.         (*(*Win2MessH(win))->tocH)->dirty = True;
  987.         if (!isOut) ReopenMessage(win);
  988.     }
  989. }
  990.  
  991.  
  992. /************************************************************************
  993.  * MessZoomSize - figure the size of a message window
  994.  ************************************************************************/
  995. void MessZoomSize(MyWindowPtr win,Rect *zoom)
  996. {
  997.     short hi,wi;
  998.     short oldRight;
  999.     TEHandle teh = Win2Body(win);
  1000.     
  1001.     if (!(wi=GetRLong(PREF_STRN+PREF_MWIDTH))) wi=GetRLong(DEF_MWIDTH);
  1002.     wi *= win->hPitch; wi += GROW_SIZE+2*TE_HMARGIN;
  1003.     zoom->right = zoom->left + MIN(zoom->right-zoom->left,wi);
  1004.  
  1005.     oldRight = (*teh)->destRect.right;
  1006.     (*teh)->destRect.right = (*teh)->destRect.left + zoom->right-zoom->left-GROW_SIZE-2*TE_HMARGIN;
  1007.     TECalText(teh);
  1008.     hi = CountTeLines(teh)*win->vPitch + 2*TE_VMARGIN + win->topMargin;
  1009.     zoom->bottom = zoom->top + MIN(zoom->bottom-zoom->top,hi);
  1010.     (*teh)->destRect.right = oldRight;
  1011. }
  1012.  
  1013. /************************************************************************
  1014.  * MessApp1 - scroll the message, not the subject
  1015.  ************************************************************************/
  1016. Boolean MessApp1(MyWindowPtr win,EventRecord *event)
  1017. {
  1018.     STEApp1((*Win2MessH(win))->stes[0],event);
  1019.     return(True);
  1020. }
  1021.  
  1022. #pragma segment Balloon
  1023. /************************************************************************
  1024.  * MessHelp - help for the message window
  1025.  ************************************************************************/
  1026. void MessHelp(MyWindowPtr win,Point mouse)
  1027. {
  1028.     Rect subRect,bodRect,priorRect;
  1029.  
  1030.     bodRect = (*Win2Body(win))->viewRect;
  1031.     
  1032.     if (PtInRect(mouse,&bodRect))
  1033.         HelpRect(&bodRect,MESS_HELP,90);
  1034.     else if (win->topMargin)
  1035.     {
  1036.         subRect = (*(*Win2MessH(win))->txes[SUBJ_HEAD-1])->viewRect;
  1037.         GetPriorityRect(win,&priorRect);
  1038.         
  1039.         if (PtInRect(mouse,&subRect))
  1040.             HelpRect(&subRect,SUB_EDIT_HELP,90);
  1041.         else if (PtInRect(mouse,&priorRect))
  1042.             PriorMenuHelp(win,&priorRect);
  1043.     }
  1044. }
  1045.  
  1046. /************************************************************************
  1047.  * PriorMenuHelp - help for the priority menu
  1048.  ************************************************************************/
  1049. void PriorMenuHelp(MyWindowPtr win,Rect *priorRect)
  1050. {
  1051.     Str255 s1,s2;
  1052.     short p = Prior2Display((SumOf(Win2MessH(win)))->priority);
  1053.     if (!HMIsBalloon())
  1054.     {
  1055.         GetRString(s1,PRIOR_MENU_HELP);
  1056.         GetRString(s2,PRIOR_STRN+5+p);
  1057.         PCat(s1,s2);
  1058.         HelpRectString(priorRect,s1,90);
  1059.     }
  1060. }
  1061.